IRIX Base Documentation 2002 November/SGI IRIX Base Documentation 2002 November.iso/usr/share/catman/p_man/cat3/SCSL/scfftm.z/scfftm

Text File | 2002-10-03 | 38.3 KB | 793 lines

SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



NNNNAAAAMMMMEEEE
     SSSSCCCCFFFFFFFFTTTTMMMM, DDDDZZZZFFFFFFFFTTTTMMMM, CCCCSSSSFFFFFFFFTTTTMMMM, ZZZZDDDDFFFFFFFFTTTTMMMM - Applies multiple real-to-complex or
     complex-to-real Fast Fourier Transforms (FFTs)

SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
     Single precision -> Single precision complex

          Fortran:
               CCCCAAAALLLLLLLL SSSSCCCCFFFFFFFFTTTTMMMM ((((_i_s_i_g_n,,,, _n,,,, _l_o_t,,,, _s_c_a_l_e,,,, _x,,,, _l_d_x,,,, _y,,,, _l_d_y,,,, _t_a_b_l_e,,,, _w_o_r_k,,,,
               _i_s_y_s))))

          C/C++:
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               iiiinnnntttt ssssccccffffffffttttmmmm ((((iiiinnnntttt _i_s_i_g_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _l_o_t,,,, ffffllllooooaaaatttt _s_c_a_l_e,,,, ffffllllooooaaaatttt *_x,,,,
               iiiinnnntttt _l_d_x,,,, ssssccccssssllll____ccccoooommmmpppplllleeeexxxx *_y,,,, iiiinnnntttt _l_d_y,,,, ffffllllooooaaaatttt *_t_a_b_l_e,,,, ffffllllooooaaaatttt *_w_o_r_k,,,,
               iiiinnnntttt *_i_s_y_s))));;;;

          C++ STL:
               ####iiiinnnncccclllluuuuddddeeee <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>>
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               iiiinnnntttt ssssccccffffffffttttmmmm ((((iiiinnnntttt _i_s_i_g_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _l_o_t,,,, ffffllllooooaaaatttt _s_c_a_l_e,,,, ffffllllooooaaaatttt *_x,,,,
               iiiinnnntttt _l_d_x,,,, ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>> *_y,,,, iiiinnnntttt _l_d_y,,,, ffffllllooooaaaatttt *_t_a_b_l_e,,,, ffffllllooooaaaatttt *_w_o_r_k,,,,
               iiiinnnntttt *_i_s_y_s))));;;;

     Double precision -> Double precision complex

          Fortran:
               CCCCAAAALLLLLLLL DDDDZZZZFFFFFFFFTTTTMMMM ((((_i_s_i_g_n,,,, _n,,,, _l_o_t,,,, _s_c_a_l_e,,,, _x,,,, _l_d_x,,,, _y,,,, _l_d_y,,,, _t_a_b_l_e,,,, _w_o_r_k,,,,
               _i_s_y_s))))

          C/C++:
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               iiiinnnntttt ddddzzzzffffffffttttmmmm ((((iiiinnnntttt _i_s_i_g_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _l_o_t,,,, ddddoooouuuubbbblllleeee _s_c_a_l_e,,,, ddddoooouuuubbbblllleeee *_x,,,,
               iiiinnnntttt _l_d_x,,,, ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx *_y,,,, iiiinnnntttt _l_d_y,,,, ddddoooouuuubbbblllleeee *_t_a_b_l_e,,,, ddddoooouuuubbbblllleeee *_w_o_r_k,,,,
               iiiinnnntttt *_i_s_y_s))));;;;

          C++ STL:
               ####iiiinnnncccclllluuuuddddeeee <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>>
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               iiiinnnntttt ddddzzzzffffffffttttmmmm ((((iiiinnnntttt _i_s_i_g_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _l_o_t,,,, ddddoooouuuubbbblllleeee _s_c_a_l_e,,,, ddddoooouuuubbbblllleeee *_x,,,,
               iiiinnnntttt _l_d_x,,,, ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>> *_y,,,, iiiinnnntttt _l_d_y,,,, ddddoooouuuubbbblllleeee *_t_a_b_l_e,,,, ddddoooouuuubbbblllleeee
               *_w_o_r_k,,,, iiiinnnntttt *_i_s_y_s))));;;;

     Single precision complex -> Single precision

          Fortran:
               CCCCAAAALLLLLLLL CCCCSSSSFFFFFFFFTTTTMMMM ((((_i_s_i_g_n,,,, _n,,,, _l_o_t,,,, _s_c_a_l_e,,,, _x,,,, _l_d_x,,,, _y,,,, _l_d_y,,,, _t_a_b_l_e,,,, _w_o_r_k,,,,
               _i_s_y_s))))

          C/C++:
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               iiiinnnntttt ccccssssffffffffttttmmmm ((((iiiinnnntttt _i_s_i_g_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _l_o_t,,,, ffffllllooooaaaatttt _s_c_a_l_e,,,,



                                                                        PPPPaaaaggggeeee 1111






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



               ssssccccssssllll____ccccoooommmmpppplllleeeexxxx *_x,,,, iiiinnnntttt _l_d_x,,,, ffffllllooooaaaatttt *_y,,,, iiiinnnntttt _l_d_y,,,, ffffllllooooaaaatttt *_t_a_b_l_e,,,,
               ffffllllooooaaaatttt *_w_o_r_k,,,, iiiinnnntttt *_i_s_y_s))));;;;

          C++ STL:
               ####iiiinnnncccclllluuuuddddeeee <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>>
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               iiiinnnntttt ccccssssffffffffttttmmmm ((((iiiinnnntttt _i_s_i_g_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _l_o_t,,,, ffffllllooooaaaatttt _s_c_a_l_e,,,,
               ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>> *_x,,,, iiiinnnntttt _l_d_x,,,, ffffllllooooaaaatttt *_y,,,, iiiinnnntttt _l_d_y,,,, ffffllllooooaaaatttt *_t_a_b_l_e,,,,
               ffffllllooooaaaatttt *_w_o_r_k,,,, iiiinnnntttt *_i_s_y_s))));;;;

     Double precision complex -> Double precision

          Fortran:
               CCCCAAAALLLLLLLL ZZZZDDDDFFFFFFFFTTTTMMMM ((((_i_s_i_g_n,,,, _n,,,, _l_o_t,,,, _s_c_a_l_e,,,, _x,,,, _l_d_x,,,, _y,,,, _l_d_y,,,, _t_a_b_l_e,,,, _w_o_r_k,,,,
               _i_s_y_s))))

          C/C++:
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               iiiinnnntttt zzzzddddffffffffttttmmmm ((((iiiinnnntttt _i_s_i_g_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _l_o_t,,,, ddddoooouuuubbbblllleeee _s_c_a_l_e,,,,
               ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx *_x,,,, iiiinnnntttt _l_d_x,,,, ddddoooouuuubbbblllleeee *_y,,,, iiiinnnntttt _l_d_y,,,, ddddoooouuuubbbblllleeee *_t_a_b_l_e,,,,
               ddddoooouuuubbbblllleeee *_w_o_r_k,,,, iiiinnnntttt *_i_s_y_s))));;;;

          C++ STL:
               ####iiiinnnncccclllluuuuddddeeee <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>>
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               iiiinnnntttt zzzzddddffffffffttttmmmm ((((iiiinnnntttt _i_s_i_g_n,,,, iiiinnnntttt _n,,,, iiiinnnntttt _l_o_t,,,, ddddoooouuuubbbblllleeee _s_c_a_l_e,,,,
               ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>> *_x,,,, iiiinnnntttt _l_d_x,,,, ddddoooouuuubbbblllleeee *_y,,,, iiiinnnntttt _l_d_y,,,, ddddoooouuuubbbblllleeee *_t_a_b_l_e,,,,
               ddddoooouuuubbbblllleeee *_w_o_r_k,,,, iiiinnnntttt *_i_s_y_s))));;;;

IIIIMMMMPPPPLLLLEEEEMMMMEEEENNNNTTTTAAAATTTTIIIIOOOONNNN
     These routines are part of the SCSL Scientific Library and can be loaded
     using either the ----llllssssccccssss or the ----llllssssccccssss____mmmmpppp option.  The ----llllssssccccssss____mmmmpppp option
     directs the linker to use the multi-processor version of the library.

     When linking to SCSL with ----llllssssccccssss or ----llllssssccccssss____mmmmpppp, the default integer size is
     4 bytes (32 bits). Another version of SCSL is available in which integers
     are 8 bytes (64 bits).  This version allows the user access to larger
     memory sizes and helps when porting legacy Cray codes.  It can be loaded
     by using the ----llllssssccccssss____iiii8888 option or the ----llllssssccccssss____iiii8888____mmmmpppp option. A program may use
     only one of the two versions; 4-byte integer and 8-byte integer library
     calls cannot be mixed.

     The C and C++ prototypes shown above are appropriate for the 4-byte
     integer version of SCSL. When using the 8-byte integer version, the
     variables of type iiiinnnntttt become lllloooonnnngggg lllloooonnnngggg and the <<<<ssssccccssssllll____fffffffftttt____iiii8888....hhhh>>>> header
     file should be included.

DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
     SSSSCCCCFFFFFFFFTTTTMMMM/DDDDZZZZFFFFFFFFTTTTMMMM computes the FFT of each column of the real matrix _X, and
     it stores the results in the corresponding column of the complex matrix
     _Y.  CCCCSSSSFFFFFFFFTTTTMMMM/ZZZZDDDDFFFFFFFFTTTTMMMM computes the corresponding inverse transforms.




                                                                        PPPPaaaaggggeeee 2222






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



     In FFT applications, it is customary to use zero-based subscripts; the
     formulas are simpler that way.  First, the function of SSSSCCCCFFFFFFFFTTTTMMMM is
     described.  Suppose that the arrays are declared as follows:

          Fortran:

               REAL    X(0:ldx-1, 0:lot-1)
               COMPLEX Y(0:ldy-1, 0:lot-1)


          C/C++:

               float x[lot][ldx];
               scsl_complex y[lot][ldy];


          C++ STL:

               float x[lot][ldx];
               complex<float> y[lot][ldy];


     where _l_d_x >= _n, _l_d_y >= _n/2 + 1.

     Then column _L of the output array is the FFT of column _L of the input
     array, using the following formula for the FFT:

                             n-1
          Y(k, L) = scale *  Sum  [ X(j, L)*w**(isign*j*k) ]
                             j=0


     for _k = 0, ..., _n/2
         _L = 0, ..., _l_o_t-1

     where:

          _w         =exp(2*_p_i*_i/_n),

          _i         = + sqrt(-1)

          _p_i        = 3.14159...,

          _i_s_i_g_n     = +1 or -1,

          _l_o_t       = the number of columns to transform

     Different authors use different conventions for which transform
     (_i_s_i_g_n = +1 or _i_s_i_g_n = -1) is used in the real-to-complex case, and what
     the _s_c_a_l_e factor should be.  Some adopt the convention that _i_s_i_g_n = 1 for
     the real-to-complex transform, and _i_s_i_g_n = -1 for the complex-to-real
     inverse.  Others use the opposite convention.  You can make these



                                                                        PPPPaaaaggggeeee 3333






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



     routines compute any of the various possible definitions, however, by
     choosing the appropriate values for _i_s_i_g_n and _s_c_a_l_e.

     The relevant fact from FFT theory is this:  If you use SSSSCCCCFFFFFFFFTTTTMMMM to take the
     real-to-complex FFT, using any particular values of _i_s_i_g_n and _s_c_a_l_e, the
     mathematical inverse function is computed by using CCCCSSSSFFFFFFFFTTTTMMMM with -_i_s_i_g_n and
     1/(_n*_s_c_a_l_e).  In particular, if you call SSSSCCCCFFFFFFFFTTTTMMMM with _i_s_i_g_n = +1 and _s_c_a_l_e
     = 1.0, you can use CCCCSSSSFFFFFFFFTTTTMMMM to compute the inverse complex-to-real FFT by
     using _i_s_i_g_n = -1 and _s_c_a_l_e = 1.0/_n.

     See the NOTES section of this man page for information about the
     interpretation of the data types described in the following arguments.

     These routines have the following arguments:

     _i_s_i_g_n     Integer.  (input)
               Specifies whether to initialize the _t_a_b_l_e array or do the
               forward or inverse Fourier transform, as follows:

               If _i_s_i_g_n = 0, the routine initializes _t_a_b_l_e and returns.  In
               this case, the only arguments used or checked are _i_s_i_g_n, _n, and
               _t_a_b_l_e.

               If _i_s_i_g_n = +1 or -1, the value of _i_s_i_g_n is the sign of the
               exponent used in the FFT formula.

     _n         Integer.  (input)
               Size of the transforms (the number of elements in each column
               of the input matrix to be transformed).  If _n is not positive,
               SSSSCCCCFFFFFFFFTTTTMMMM or CCCCSSSSFFFFFFFFTTTTMMMM returns without computing a transform.

     _l_o_t       Integer.  (input)
               The number of transforms to be computed (or "lot size").  This
               is the number of elements in each row of the input and output
               matrix.  If _l_o_t is not positive, the routine returns without
               computing a transform.

     _s_c_a_l_e     Scale factor. (input)
               SSSSCCCCFFFFFFFFTTTTMMMM: Single precision.
               DDDDZZZZFFFFFFFFTTTTMMMM: Double precision.
               CCCCSSSSFFFFFFFFTTTTMMMM: Single precision.
               ZZZZDDDDFFFFFFFFTTTTMMMM: Double precision.
               Each element of the output array is multiplied by _s_c_a_l_e after
               taking the transform, as defined in the preceding formula.

     _x         Array of dimensions (_l_d_x, _l_o_t).  (input)
               SSSSCCCCFFFFFFFFTTTTMMMM: Single precision array.
               DDDDZZZZFFFFFFFFTTTTMMMM: Double precision array.
               CCCCSSSSFFFFFFFFTTTTMMMM: Single precision complex array.
               ZZZZDDDDFFFFFFFFTTTTMMMM: Double precision complex array.
               Input array of values to be transformed.




                                                                        PPPPaaaaggggeeee 4444






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



     _l_d_x       Integer.  (input)
               The number of rows in the _x array, as it was declared in the
               calling program (the leading dimension of _x).
               SSSSCCCCFFFFFFFFTTTTMMMM, DDDDZZZZFFFFFFFFTTTTMMMM:  _l_d_x >= MMMMAAAAXXXX(_n, 1).
               CCCCSSSSFFFFFFFFTTTTMMMM, ZZZZDDDDFFFFFFFFTTTTMMMM:  _l_d_x >= MMMMAAAAXXXX(_n/2 + 1, 1).

     _y         Array of dimensions (_l_d_y, _l_o_t).  (input or output)
               SSSSCCCCFFFFFFFFTTTTMMMM: Single precision complex array.
               DDDDZZZZFFFFFFFFTTTTMMMM: Double precision complex array.
               CCCCSSSSFFFFFFFFTTTTMMMM: Single precision array.
               ZZZZDDDDFFFFFFFFTTTTMMMM: Double precision array.

               Output array of transformed values.  Each column of the output
               array, _y, is the FFT of the corresponding column of the input
               array, _x, computed according to the preceding formula.

               The output array may be equivalenced to the input array. In
               that case, the transform is done in place and the input array
               is overwritten with the transformed values. In this case, the
               following conditions on the leading dimensions must hold:

               SSSSCCCCFFFFFFFFTTTTMMMM, DDDDZZZZFFFFFFFFTTTTMMMM:  _l_d_x = 2_l_d_y.
               CCCCSSSSFFFFFFFFTTTTMMMM, ZZZZDDDDFFFFFFFFTTTTMMMM:  _l_d_y = 2_l_d_x.

     _l_d_y       Integer.  (input)
               Number of rows in the _y array, as declared in the calling
               program (the leading dimension of _y).
               SSSSCCCCFFFFFFFFTTTTMMMM, DDDDZZZZFFFFFFFFTTTTMMMM:  _l_d_y >= MMMMAAAAXXXX(_n/2 + 1, 1).
               CCCCSSSSFFFFFFFFTTTTMMMM, ZZZZDDDDFFFFFFFFTTTTMMMM:  _l_d_y >= MMMMAAAAXXXX(_n, 1).

     _t_a_b_l_e     Array of dimension (_n + _N_F_R) (input or output)
               SSSSCCCCFFFFFFFFTTTTMMMM, CCCCSSSSFFFFFFFFTTTTMMMM: Single precision array.
               DDDDZZZZFFFFFFFFTTTTMMMM, ZZZZDDDDFFFFFFFFTTTTMMMM: Double precision array.
               Table of factors and roots of unity.  See the description of
               the _i_s_y_s argument for the value of _N_F_R.

               If _i_s_i_g_n = 0, the routine initializes _t_a_b_l_e (_t_a_b_l_e is output
               only).

               If _i_s_i_g_n = +1 or -1, the values in _t_a_b_l_e are assumed to be
               initialized already by a prior call with _i_s_i_g_n = 0 (_t_a_b_l_e is
               input only).

     _w_o_r_k      Array of dimension _n + 2
               SSSSCCCCFFFFFFFFTTTTMMMM, CCCCSSSSFFFFFFFFTTTTMMMM: Single precision array.
               DDDDZZZZFFFFFFFFTTTTMMMM, ZZZZDDDDFFFFFFFFTTTTMMMM: Double precision array.
               Work array used for intermediate calculations.  Its address
               space must be different from that of the input and output
               arrays.






                                                                        PPPPaaaaggggeeee 5555






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



     _i_s_y_s      Integer array dimensioned 0000........_i_s_y_s((((0000)))).
               An array that gives implementation-specific information.  All
               features and functions of the FFT routines specific to any
               particular implementation are confined to this _i_s_y_s array.

               In the Origin series implementation, _i_s_y_s((((0000))))====0000 and _i_s_y_s((((0000))))====1111
               are supported.  In SCSL versions prior to 1.3, only _i_s_y_s((((0000))))====0000
               was allowed. For _i_s_y_s((((0000))))====0000, _N_F_R====11115555, and for _i_s_y_s((((0000))))====1111, _N_F_R====222255556666.
               The _N_F_R words of storage in the _t_a_b_l_e array contain a
               factorization of the length of the transform.

               The smaller value of _N_F_R for _i_s_y_s((((0000))))====0000 is historical. It is too
               small to store all the required factors for the highest
               performing FFT, so when _i_s_y_s((((0000))))====0000, extra space is allocated
               when the _t_a_b_l_e array is initialized. To avoid memory leaks,
               this extra space must be deallocated when the _t_a_b_l_e array is no
               longer needed. The SSSSCCCCFFFFFFFFTTTTMMMMFFFF routine is used to release this
               memory. Due to the potential for memory leaks, the use of
               _i_s_y_s((((0000))))====0000 should be avoided.

               For _i_s_y_s((((0000))))====1111, the value of _N_F_R is large enough so that no
               extra memory needs to be allocated, and there is no need to
               call SSSSCCCCFFFFFFFFTTTTMMMMFFFF to release memory. If called, it does nothing.

               NOTE: _i_s_y_s((((0000))))====1111 means that _i_s_y_s is an integer array with two
               elements. The second element, _i_s_y_s((((1111)))), will not be accessed.

NNNNOOOOTTTTEEEESSSS
     The following data types are described in this documentation:

          TTTTeeeerrrrmmmm UUUUsssseeeedddd                     DDDDaaaattttaaaa ttttyyyyppppeeee

     Fortran:

          Array dimensioned 0000........_n----1111      xxxx((((0000::::nnnn----1111))))

          Array of dimensions (_m,_n)     xxxx((((mmmm,,,,nnnn))))

          Array of dimensions (_m,_n,_p)   xxxx((((mmmm,,,,nnnn,,,,pppp))))

          Integer                       IIIINNNNTTTTEEEEGGGGEEEERRRR (IIIINNNNTTTTEEEEGGGGEEEERRRR****8888 for ----llllssssccccssss____iiii8888[[[[____mmmmpppp]]]])

          Single precision              RRRREEEEAAAALLLL

          Double precision              DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN

          Single precision complex      CCCCOOOOMMMMPPPPLLLLEEEEXXXX

          Double precision complex      DDDDOOOOUUUUBBBBLLLLEEEE CCCCOOOOMMMMPPPPLLLLEEEEXXXX






                                                                        PPPPaaaaggggeeee 6666






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



     C/C++:

          Array dimensioned 0000........_n----1111      xxxx[[[[_n]]]]

          Array of dimensions (_m,_n)     xxxx[[[[mmmm****nnnn]]]] oooorrrr xxxx[[[[nnnn]]]][[[[mmmm]]]]

          Array of dimensions (_m,_n,_p)   xxxx[[[[mmmm****nnnn****pppp]]]] oooorrrr xxxx[[[[pppp]]]][[[[nnnn]]]][[[[mmmm]]]]

          Integer                       iiiinnnntttt (lllloooonnnngggg lllloooonnnngggg for ----llllssssccccssss____iiii8888[[[[____mmmmpppp]]]])

          Single precision              ffffllllooooaaaatttt

          Double precision              ddddoooouuuubbbblllleeee

          Single precision complex      ssssccccssssllll____ccccoooommmmpppplllleeeexxxx

          Double precision complex      ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx

     C++ STL:

          Array dimensioned 0000........_n----1111      xxxx[[[[_n]]]]

          Array of dimensions (_m,_n)     xxxx[[[[mmmm****nnnn]]]] oooorrrr xxxx[[[[nnnn]]]][[[[mmmm]]]]

          Array of dimensions (_m,_n,_p)   xxxx[[[[mmmm****nnnn****pppp]]]] oooorrrr xxxx[[[[pppp]]]][[[[nnnn]]]][[[[mmmm]]]]

          Integer                       iiiinnnntttt (lllloooonnnngggg lllloooonnnngggg for ----llllssssccccssss____iiii8888[[[[____mmmmpppp]]]])

          Single precision              ffffllllooooaaaatttt

          Double precision              ddddoooouuuubbbblllleeee

          Single precision complex      ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>>

          Double precision complex      ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>>

CCCCAAAAUUUUTTTTIIIIOOOONNNNSSSS
     Transform sizes with a prime factor exceeding 22223332222----1111 are not supported for
     the 8-byte integer version of the library.

     In addition to the _w_o_r_k array, the FFT routines also dynamically allocate
     scratch space from the stack. The amount of space allocated can be
     slightly bigger than the size of the largest processor cache. For single
     processor runs, the default stack size is large enough that these
     allocations generally cause no problems. But for parallel runs, you need
     to ensure that the stack size of slave threads is big enough to hold this
     scratch space. Failure to reserve sufficient stack space will cause
     programs to dump core due to stack overflows.  The stack size of MP
     library slave threads is controlled via the MMMMPPPP____SSSSLLLLAAAAVVVVEEEE____SSSSTTTTAAAACCCCKKKKSSSSIIIIZZZZEEEE
     environment variable or the mmmmpppp____sssseeeetttt____ssssllllaaaavvvveeee____ssssttttaaaacccckkkkssssiiiizzzzeeee(((()))) library routine. See
     the mmmmpppp(3C), mmmmpppp(3F) and ppppeeee____eeeennnnvvvviiiirrrroooonnnn(5) reference pages for more information
     on controlling the slave stack size. For pthreads applications, the



                                                                        PPPPaaaaggggeeee 7777






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



     thread's stack size is specified as one of many creation attributes
     provided in the pthread_attr_t argument to pppptttthhhhrrrreeeeaaaadddd____ccccrrrreeeeaaaatttteeee(3P).  The
     stacksize attribute should be set explicitly to a non-default value using
     the pppptttthhhhrrrreeeeaaaadddd____aaaattttttttrrrr____sssseeeettttssssttttaaaacccckkkkssssiiiizzzzeeee(3P) call, described in the
     pppptttthhhhrrrreeeeaaaadddd____aaaattttttttrrrr____iiiinnnniiiitttt(3P) man page.

     Care must be exercised if copies of the _t_a_b_l_e array are used: even though
     a copy exists, the original must persist. As an example, the following
     code will nnnnooootttt work:

          #include <scsl_fft.h>
          float x[56][129];
          scsl_complex y[56][65];
          float table[128 + 256];
          float work[128+2];
          int isys[2];
          isys[0] = 1;
          {
            float table_orig[128+256];

            scfftm(0, 128, 50, 1.0f, (float *) x, 129,
                  (scsl_complex *) y, 65, table_orig, work, isys);
            bcopy(table_orig, table, (128+256)*sizeof(float));
          }
          scfftm(1, 128, 50, 1.0f, (float *) x, 129,
                 (scsl_complex *) y, 65, table, work, isys);


     In this example, because _t_a_b_l_e__o_r_i_g is a stack variable that does not
     persist outside of the code block delimited by the braces, the data in
     the copy, _t_a_b_l_e, are not guaranteed to be valid. However, the following
     code will work because _t_a_b_l_e__o_r_i_g is persistent:

          #include <scsl_fft.h>
          float x[56][129];
          scsl_complex y[56][65];
          float table_orig[128+256];
          float table[128 + 256];
          float work[128+2];
          int isys[2];
          isys[0] = 1;
          scfftm(0, 128, 50, 1.0f, (float *) x, 129,
                (scsl_complex *) y, 65, table_orig, work, isys);
          bcopy(table_orig, table, (128+256)*sizeof(float));
          scfftm(1, 128, 50, 1.0f, (float *) x, 129,
                (scsl_complex *) y, 65, table, work, isys);


EEEEXXXXAAAAMMMMPPPPLLLLEEEESSSS
     These examples use the table and workspace sizes appropriate to the
     Origin series.




                                                                        PPPPaaaaggggeeee 8888






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



     Example 1:  Initialize the TTTTAAAABBBBLLLLEEEE array in preparation for doing an FFT of
     size 128.  In this case only the _i_s_i_g_n, _n, and _t_a_b_l_e arguments are used;
     you may use dummy arguments or zeros for the other arguments in the
     subroutine call.

     Fortran:

           REAL TABLE(128 + 256)
           INTEGER ISYS(0:1)
           ISYS(0) = 1
           CALL SCFFTM(0, 128, 1, 0.0, DUMMY, 1, DUMMY, 1,
          &            TABLE, DUMMY, ISYS)


     C/C++:

     #include <scsl_fft.h>
     float table[128 + 256];
     int isys[2];
     isys[0] = 1;
     scfftm(0, 128, 0, 0.0f, NULL, 1, NULL, 1, table, NULL, isys);


     C++ STL:

     #include <complex.h>
     #include <scsl_fft.h>
     float table[128 + 256];
     int isys[2];
     isys[0] = 1;
     scfftm(0, 128, 0, 0.0f, NULL, 1, NULL, 1, table, NULL, isys);


     Example 2:  XXXX is a real array of dimension (0...128, 0...55), and YYYY is a
     complex array of dimension (0...64, 0...55).  The first 128 elements in
     each column of XXXX contain data; the extra element forces an odd leading
     dimension.  Take the FFT of the first 50 columns of XXXX and store the
     results in the first 50 columns of YYYY.  Before taking the FFT, initialize
     the TTTTAAAABBBBLLLLEEEE array, as in example 1.

     Fortran:

     REAL    X(0:128, 0:55)
     COMPLEX Y(0:64,  0:55)
     REAL    TABLE(128 + 256)
     REAL    WORK(128+2)
     INTEGER ISYS(0:1)
     ISYS(0) = 1
     CALL SCFFTM(0, 128, 50, 1.0, X, 129, Y, 65, TABLE, WORK, ISYS)
     CALL SCFFTM(1, 128, 50, 1.0, X, 129, Y, 65, TABLE, WORK, ISYS)





                                                                        PPPPaaaaggggeeee 9999






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



     C/C++:

          #include <scsl_fft.h>
          float x[56][129];
          scsl_complex y[56][65];
          float table[128 + 256];
          float work[128+2];
          int isys[2];
          isys[0] = 1;
          scfftm(0, 128, 50, 1.0f, (float *) x, 129,
                (scsl_complex *) y, 65, table, work, isys);
          scfftm(1, 128, 50, 1.0f, (float *) x, 129,
                (scsl_complex *) y, 65, table, work, isys);


     C++ STL:

          #include <complex.h>
          #include <scsl_fft.h>
          float x[56][129];
          complex<float> y[56][65];
          float table[128 + 256
          int isys[2];
          isys[0] = 1;
          scfftm(0, 128, 50, 1.0f, (float *) x, 129,
                (complex<float> *) y, 65, table, work, isys);
          scfftm(1, 128, 50, 1.0f, (float *) x, 129,
                (complex<float> *) y, 65, table, work, isys);


     Example 3:  With _X and _Y as in example 2, take the inverse FFT of Y and
     store it back in _X. Note that the leading dimension of _X must be
     increased to 2*_l_d_y. The scale factor 1.0/128.0 is used.  Assume that the
     _T_A_B_L_E array is initialized already.

     Fortran:

           REAL    X(0:129, 0:55)
           COMPLEX Y(0:64,  0:55)
           ...
           CALL CSFFTM(-1, 128, 50, 1.0/128.0, Y, 65, X, 130,
          &            TABLE, WORK, ISYS)


     C/C++:

          float x[56][130];
          scsl_complex y[56][65];
          csfftm(-1, 128, 50, 1.0f/128.0f, (scsl_complex *) y, 65,
                (float *) x, 130, table, work, isys);





                                                                       PPPPaaaaggggeeee 11110000






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



     C++ STL:

          float x[56][130];
          complex<float> y[56][65];
          csfftm(-1, 128, 50, 1.0f/128.0f, (complex<float> *) y, 65,
                (float *) x, 130, table, work, isys);


     Example 4:  Perform the same computation as in example 2, but equivalence
     the input and output arrays to save storage space.  In this case, a row
     must be added to _X, because it is equivalenced to a complex array.  Use
     the 8-byte integer version of SCSL.

     Fortran:

           REAL    X(0:129, 0:55)
           COMPLEX Y(0:64,  0:55)
           EQUIVALENCE ( X(0, 0), Y(0, 0) )
           REAL    TABLE(128 + 256)
           REAL    WORK(128+2)
           INTEGER*8 ISYS(0:1)
           ISYS(0) = 1_8
           CALL SCFFTM(0_8, 128_8, 50_8, 1.0, X, 130_8, Y, 65_8,
          &            TABLE, WORK, ISYS)
           CALL SCFFTM(1_8, 128_8, 50_8, 1.0, X, 130_8, Y, 65_8,
          &            TABLE, WORK, ISYS)


     C/C++:

     #include <scsl_fft_i8.h>
     float *x;
     scsl_complex y[56][65];
     float table[128 + 256];
     float work[128+2];
     long long isys[2];
     isys[0] = 1LL;
     x = (float *) &y[0][0];
     scfftm(0LL, 128LL, 50LL, 1.0f, x, 130LL, (scsl_complex *) y, 65LL,
           table, work, isys);
     scfftm(1LL, 128LL, 50LL, 1.0f, x, 130LL, (scsl_complex *) y, 65LL,
           table, work, isys);


     C++ STL:

          #include <complex.h>
          #include <scsl_fft_i8.h>
          float *x;
          complex<float> y[56][65];
          float table[128 + 256];
          float work[128+2];



                                                                       PPPPaaaaggggeeee 11111111






SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))                                                          SSSSCCCCFFFFFFFFTTTTMMMM((((3333SSSS))))



          long long isys[2];
          isys[0] = 1LL;
          x = (float *) &y[0][0];
          scfftm(0LL, 128LL, 50LL, 1.0f, x, 130LL,
                (complex<float> *) y, 65LL, table, work, isys);
          scfftm(1LL, 128LL, 50LL, 1.0f, x, 130LL,
                (complex<float> *) y, 65LL, table, work, isys);


     Example 5:  Perform the same computation as in example 2, but assume that
     the lower bound of each Fortran array is 1, rather than 0.  No change is
     made in the subroutine calls.

     Fortran:

     REAL    X(129, 56)
     COMPLEX Y(65, 56)
     CALL SCFFTM(0, 128, 50, 1.0, X, 129, Y, 65, TABLE, WORK,= ISYS)
     CALL SCFFTM(1, 128, 50, 1.0, X, 129, Y, 65, TABLE, WORK, ISYS)


SSSSEEEEEEEE AAAALLLLSSSSOOOO
     IIIINNNNTTTTRRRROOOO____FFFFFFFFTTTT(3S), IIIINNNNTTTTRRRROOOO____SSSSCCCCSSSSLLLL(3S), CCCCCCCCFFFFFFFFTTTT(3S), CCCCCCCCFFFFFFFFTTTTMMMM(3S), SSSSCCCCFFFFFFFFTTTT(3S)





























                                                                       PPPPaaaaggggeeee 11112222